1. Field of the Invention
The present invention relates to computer program product, methodology, systems, and/or apparatus for making modifications to a Graphical User Interface (GUI) display and, more particularly, relates to a technique for allowing such modifications to be made in an extremely convenient and efficient manner because the code underlying the display is not modified.
2. Description of Prior Art
Most people who interact with the world of computers, computer networks, computer storage systems, etc., can probably be classified as users of this technology. Many, if not most of us, own personal computers (PCs) or use them at our jobs. We are Internet subscribers or users, and we take convenient advantage of technological advances which have been provided for us. We are enjoying the benefits of the computer revolution. However, there is a group set apart from ordinary users, a special subset of users who are also developers of this technology who have necessary skills and training to perform successfully in this competitive development activity. That subset of individuals (computer scientists, computer programmers, code developers, computer technologists, etc.) is constantly challenged. They are normally under great pressure to produce new product offerings having enhanced features within constraining deadlines, and the amazing growth of the computer industry is to a large extent a result of efforts by these individuals to meet these goals within these deadlines. Accordingly, these individuals, and perhaps software developers in particular, are strongly motivated to find ways or techniques to make their tasks easier.
One category of tasks confronting certain software developers is the category of modifying a large body of complex code that has been developed by a large developer team over a long period of time into a substantially fixed body of code. Any modification of that type of code usually ripples throughout the entire body of that code causing severe rework problems. These modifications can be inordinately frustrating and can take immense amounts of time to accomplish. In certain software development environments not only can there be many different products under development at the same time, but the specifications of these products may be continuously changing or evolving. Accordingly, there is a need to react quickly to these changes in direction to the product lines. When there are severe pressures to meet deadlines on a number of different development fronts, the last thing a development team needs is the large headache of rewriting one or more large bodies of code.
One example of this kind of complex code is that which controls the terminal screen presentation on a GUI in a computer system or computer network. The network may, for example, be part of a storage network or storage area network (SAN). And, the screen presentation may include toolbars with accompanying menus and menu items as well as displays such as graphs, maps or trees. Examples of these kinds of presentations and techniques for enabling them are disclosed in U.S. patent application Ser. No. 09/916,102 filed Jul. 26, 2001, entitled: “Plug and Play Interface for User Actions”, having inventors Munish T. Desai, Brian R. Gruttadauria and Andreas L. Bauer, assigned to the assignee of the present invention, and hereby incorporated by reference herein in its entirety.
In one of those displays to which the term “tree” presentation or display is applied, one element in the tree is visually connected from another element in the tree somewhat reminiscent of a tree-branching, giving rise to the term. This display would be familiar to users of various commercially-available software packages, such as Microsoft's Windows Explorer® software. The element at treetop is normally called a “root node” or “parent” and elements connected directly below and from that root node are termed “children” of that root node. Children of that root node's children are “grandchildren” of the root node, etc., comprising the “descendents” of that root node. Any child node in the descendent hierarchy can be selected or considered as a “local root node” for its descendents. These displayed nodes, which are visible to computer users, are normally constructed within the computer system or network as software “objects” which are then handled or controlled by object-oriented software running in the system or network.
A typical computer network being used today that can run object oriented software is a client-server network, the client being the user (GUI) or workstation and the server being software (discrete or distributed throughout the network) which serves the client. In this network, a computer system can employ one or more object-oriented computer languages such as C++, XML (eXtensible Markup Language), JAVA, and/or others. Briefly, an object, in computer software terms, is a dedicated area of memory which can be thought of as an impervious container holding both data and instructions within itself, both defining itself and its relationships to other objects in the computer system or network. Such object or node can send and receive messages to and from other objects, respond and react to such messages (e.g. commands) but shall normally be impervious to internal scrutiny. For example, in a computer data storage system (a kind of computer) each object (system object) may describe or relate to a specific tangible detail in the storage system or in the storage system's processor (e.g., details such as those describing or relating to aspects of operation of the processor's cooling-fan, power switch, cache memory, power supply, disk drive interface, individual disks, etc.). These tangible objects (nodes) within the storage processor in the storage system can send messages to each other within the storage system and to other objects outside the storage system over the network with which they are operatively coupled. The relationship between these specific objects in the storage processor is usually visualized or characterized as the tree to which reference was earlier made. In this tree, many children may typically hang from the same parent. In addition to these kinds of tangible objects, logical units (LUNs) are other nodes or objects that can be contained within a tree. Also, the storage processor itself and/or the storage system itself can be objects and interact as individual nodes, respectively, with other nodes in their network.
The tree relationship of these node objects may be displayed in tree fashion on the terminal screen of the GUI. This display is controlled, in part, by a large, fixed body of complex code which “paints” this tree display on the terminal screen, and to which reference was made hereinabove. What is needed, therefore, is a convenient and efficient technique for use by software developers to modify their complex code responsive to requests by customers or to their own company directives, as new functionality which was not part of the original, arduous code development is discovered/developed and is sought to be added to the original. Embodiments of the present invention satisfy this need otherwise left unsatisfied by the prior art.